home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / msdos / raytrace / rayshade / src / expr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-04-30  |  6.1 KB  |  296 lines
  1. /*
  2.  * expr.c
  3.  *
  4.  * Copyright (C) 1989, 1991, Craig E. Kolb, Rod G. Bogart
  5.  * All rights reserved.
  6.  *
  7.  * This software may be freely copied, modified, and redistributed
  8.  * provided that this copyright notice is preserved on all copies.
  9.  *
  10.  * You may not distribute this software, in whole or in part, as part of
  11.  * any commercial product without the express consent of the authors.
  12.  * 
  13.  * There is no warranty or other guarantee of fitness of this software
  14.  * for any purpose.  It is provided solely "as is".
  15.  *
  16.  * $Id: expr.c,v 4.0 91/07/17 14:30:36 kolb Exp Locker: kolb $
  17.  *
  18.  * $Log:    expr.c,v $
  19.  * Revision 4.0  91/07/17  14:30:36  kolb
  20.  * Initial version.
  21.  * 
  22.  */
  23. #include "common.h"
  24.  
  25. Expr *TimeExpr, *FrameExpr;
  26.  
  27. static Expr *ExprCreate();
  28. void ExprFree();
  29.  
  30. Expr *
  31. ExprFloatCreate(val, timevary)
  32. Float val;
  33. int timevary;
  34. {
  35.     Expr *res;
  36.  
  37.     res = ExprCreate(FLOAT_EXPR, timevary);
  38.     res->value = val;
  39.     return res;
  40. }
  41.  
  42. Expr *
  43. ExprReuseFloatCreate(val)
  44. Float val;
  45. {
  46.     Expr *res;
  47.  
  48.     /* this should get the expr from a magic list
  49.      * that will reuse the exprs.
  50.      * But not yet...
  51.      */
  52.     res = ExprCreate(FLOAT_EXPR, FALSE);
  53.     res->value = val;
  54.     return res;
  55. }
  56.  
  57. Expr *
  58. ExprRayMalloc()
  59. {
  60.     return (Expr *)RayMalloc(sizeof(Expr));
  61. }
  62.  
  63. static
  64. Expr *
  65. ExprCreate(type, timevary)
  66. int type, timevary;
  67. {
  68.     Expr *res;
  69.  
  70.     res = ExprRayMalloc();
  71.     res->type = type;
  72.     res->timevary = timevary;
  73.     res->symtab = FALSE;
  74.     res->nparams = 0;
  75.     res->params = (Expr **)NULL;
  76.     res->function = (Float (*)())NULL;
  77.     res->value = 0.0;
  78.     res->timenow = -FAR_AWAY;
  79.     return res;    
  80. }
  81.  
  82. Float
  83. ExprEval(expr)
  84. Expr *expr;    /* Expression to evaluate */
  85. {
  86.     /*
  87.      * If the expression is a time-varying function,
  88.      * and its time is incorrect, evaluate at
  89.      * the current time.
  90.      */
  91.     if (expr->timevary && expr->nparams && 
  92.         !equal(TimeExpr->value, expr->timenow)) {
  93.         if (expr->nparams == 1) {
  94.             expr->value = (*expr->function)
  95.                 (ExprEval(expr->params[0]));
  96.         } else if (expr->nparams == 2) {
  97.             expr->value = (*expr->function)
  98.                 (ExprEval(expr->params[0]),
  99.                  ExprEval(expr->params[1]));
  100.         } else if (expr->nparams == 3) {
  101.             expr->value = (*expr->function)
  102.                 (ExprEval(expr->params[0]),
  103.                  ExprEval(expr->params[1]),
  104.                  ExprEval(expr->params[2]));
  105.         } else if (expr->nparams == 4) {
  106.             expr->value = (*expr->function)
  107.                 (ExprEval(expr->params[0]),
  108.                  ExprEval(expr->params[1]),
  109.                  ExprEval(expr->params[2]),
  110.                  ExprEval(expr->params[3]));
  111.         } else if (expr->nparams == 5) {
  112.             expr->value = (*expr->function)
  113.                 (ExprEval(expr->params[0]),
  114.                  ExprEval(expr->params[1]),
  115.                  ExprEval(expr->params[2]),
  116.                  ExprEval(expr->params[3]),
  117.                  ExprEval(expr->params[4]));
  118.         } else if (expr->nparams > 5)
  119.             RLerror(RL_PANIC, "Expression with > 5 args?\n","","","");
  120.         expr->timenow = TimeExpr->value;
  121.     }
  122.     return expr->value;
  123. }
  124.  
  125. Expr *
  126. ExprFunctionCreate(fp, nparams, params, timevary)
  127. Float (*fp)();
  128. int nparams, timevary;
  129. Expr **params;
  130. {
  131.     Expr *res;
  132.  
  133.     res = ExprCreate(FLOAT_EXPR, timevary);
  134.     res->function = fp;
  135.     res->nparams = nparams;
  136.     res->params = params;
  137.  
  138.     return res;
  139. }
  140.  
  141. Expr *
  142. ExprResolve1(a, fp, timevary)
  143. Expr *a;
  144. Float (*fp)();
  145. int timevary;
  146. {
  147.     Expr **params, *res;
  148.  
  149.     if (!timevary && !a->timevary) {
  150.         res = ExprFloatCreate((*fp)(a->value), FALSE);
  151.         ExprFree(a);
  152.         return res;
  153.     } else {
  154.         params = (Expr **)RayMalloc(sizeof(Expr *));
  155.         params[0] = a;
  156.         return ExprFunctionCreate(fp, 1, params, TRUE);
  157.     }
  158. }
  159.  
  160. Expr *
  161. ExprResolve2(a, b, fp, timevary)
  162. Expr *a, *b;
  163. Float (*fp)();
  164. int timevary;
  165. {
  166.     Expr **params, *res;
  167.     if (!timevary && !a->timevary && !b->timevary) {
  168.         res = ExprFloatCreate((*fp)(a->value, b->value), FALSE);
  169.         ExprFree(a);
  170.         ExprFree(b);
  171.         return res;
  172.     } else {
  173.         params = (Expr **)RayMalloc(2 * sizeof(Expr *));
  174.         params[0] = a;
  175.         params[1] = b;
  176.         return ExprFunctionCreate(fp, 2, params, TRUE);
  177.     }
  178. }
  179.  
  180. Expr *
  181. ExprResolve3(a, b, c, fp, timevary)
  182. Expr *a, *b, *c;
  183. Float (*fp)();
  184. int timevary;
  185. {
  186.     Expr **params, *res;
  187.     if (!timevary && !a->timevary && !b->timevary && !c->timevary) {
  188.         res = ExprFloatCreate((*fp)(a->value, b->value, c->value), 
  189.                       FALSE);
  190.         ExprFree(a);
  191.         ExprFree(b);
  192.         ExprFree(c);
  193.         return res;
  194.     } else {
  195.         params = (Expr **)RayMalloc(3 * sizeof(Expr *));
  196.         params[0] = a;
  197.         params[1] = b;
  198.         params[2] = c;
  199.         return ExprFunctionCreate(fp, 3, params, TRUE);
  200.     }
  201. }
  202.  
  203. Expr *
  204. ExprResolve4(a, b, c, d, fp, timevary)
  205. Expr *a, *b, *c, *d;
  206. Float (*fp)();
  207. int timevary;
  208. {
  209.     Expr **params, *res;
  210.     if (!timevary && !a->timevary && !b->timevary && !c->timevary &&
  211.         !d->timevary) {
  212.         res = ExprFloatCreate((*fp)(a->value, b->value, c->value, 
  213.                         d->value), FALSE);
  214.         ExprFree(a);
  215.         ExprFree(b);
  216.         ExprFree(c);
  217.         ExprFree(d);
  218.         return res;
  219.     } else {
  220.         params = (Expr **)RayMalloc(4 * sizeof(Expr *));
  221.         params[0] = a;
  222.         params[1] = b;
  223.         params[2] = c;
  224.         params[3] = d;
  225.         return ExprFunctionCreate(fp, 4, params, TRUE);
  226.     }
  227. }
  228.  
  229. Expr *
  230. ExprResolve5(a, b, c, d, e, fp, timevary)
  231. Expr *a, *b, *c, *d, *e;
  232. Float (*fp)();
  233. int timevary;
  234. {
  235.     Expr **params, *res;
  236.     if (!timevary && !a->timevary && !b->timevary && !c->timevary &&
  237.         !d->timevary && !e->timevary) {
  238.         res = ExprFloatCreate((*fp)(a->value, b->value, c->value, 
  239.                         d->value, e->value), FALSE);
  240.         ExprFree(a);
  241.         ExprFree(b);
  242.         ExprFree(c);
  243.         ExprFree(d);
  244.         ExprFree(e);
  245.         return res;
  246.     } else {
  247.         params = (Expr **)RayMalloc(5 * sizeof(Expr *));
  248.         params[0] = a;
  249.         params[1] = b;
  250.         params[2] = c;
  251.         params[3] = d;
  252.         params[4] = e;
  253.         return ExprFunctionCreate(fp, 5, params, TRUE);
  254.     }
  255. }
  256.  
  257. ExprAssoc *
  258. AssocCreate(lhs, expr, next)
  259. Float *lhs;
  260. Expr *expr;
  261. ExprAssoc *next;
  262. {
  263.     ExprAssoc *new;
  264.  
  265.     new = (ExprAssoc *)RayMalloc(sizeof(ExprAssoc));
  266.     new->lhs = lhs;
  267.     new->expr = expr;
  268.     new->next = next;
  269.     return new;
  270. }
  271.  
  272. void
  273. TimeSet(time)
  274. Float time;
  275. {
  276.     TimeExpr->value = time;
  277. }
  278.  
  279. void
  280. FrameSet(frame)
  281. Float frame;
  282. {
  283.     FrameExpr->value = frame;
  284. }
  285.  
  286. void
  287. ExprFree(expr)
  288. Expr *expr;
  289. {
  290.     if (!expr->symtab) {
  291.         if (expr->type == BUILTIN_EXPR && expr->params)
  292.             free((voidstar)expr->params);
  293.         free((voidstar)expr);
  294.     }
  295. }
  296.